what this |buffering| mean ? or prebuffering is what it means ?

It's equivalent to JS isBufferingSpeech so pre-connect buffer, it's not exposed anywhere, but we can rename it

should you allow .connected here ? that might means reconnect ?

there's no .reconnecting state in the agent itself, this overall Agent.State is a little artificial as it's derived partially from the room, as mentioned above: #789 (comment)

should you handle the noOp operation ? like adding a

private func assign(_ new: State) {
guard new != state else { return }
state = new
}

Then use
assign(.connected(agentState: participant.agentState,
audioTrack: participant.agentAudioTrack,
avatarVideoTrack: participant.avatarVideoTrack))

From the perspective of UI framework, it does not really matter (for perf) https://medium.com/airbnb-engineering/understanding-and-improving-swiftui-performance-37b77ac61896 as we use the non-equatable (default) comparison for the State struct.

should this TranscriptionDelegateReceiver hold the room strong reference ? or it should be weak ?

Could you please confirm that there is no cycle reference if they hold each other strongly

I think Room does not keep a strong ref to the delegates

Can this messages() will be called multiple times?
If yes, the current code stores a single continuation, calling messages() again overwrites it and could it leave the old stream hanging ?
In that case, I am a bit worrying that it never finish the stream either, so consumers can hang ?

And I wonder if we should have an explicit stop function like
func stop() {
room?.remove(delegate: self)
room = nil
continuation?.finish()
continuation = nil
}

This is a general problem with AsyncStream<> being exposed here (without storing anything internally). It's not intended to be used by multiple consumers at all (known issue). There's also no equivalent AnyAsyncSequence (as AnyPublisher).

it never finish the stream either,

It can be cancelled from the outside like this:

let locations = AsyncLocationStream()

let task = Task {
    for await location in locations.stream {
        print(location)
    }
}

task.cancel()

Re: stream idempotence, I think we've got 2 choices:

• leave is as is - it won't register another consumer for this topic, just throwing StreamError.handlerAlreadyRegistered
• unregister before registering, so the previous stream will stop working - I think that's the worst one

any chance that messages() will throw ?
If that is possible, this loop just exits quietly.

How about wrapping in do/catch and log so users know why a stream stopped.

6846414 yeah I think it's doable

curiously, when room gets changed, do we cancel the current tasks ? or do we need to worry about the cancellation for disconnect ?

the room is immutable public let room: Room, I don't see a reason for cancelling on disconnect while we wanna observe connection state as well: connectionState = room.connectionState

This localMedia class is @mainactor,
I think you should run code on the main thread:
await MainActor.run {
self.microphoneTrack = localParticipant.firstAudioTrack
self.cameraTrack = localParticipant.firstCameraVideoTrack
self.screenShareTrack = localParticipant.firstScreenShareVideoTrack
self.isMicrophoneEnabled = localParticipant.isMicrophoneEnabled()
self.isCameraEnabled = localParticipant.isCameraEnabled()
self.isScreenShareEnabled = localParticipant.isScreenShareEnabled()
}

We're compiling in Swift 6 mode with strict concurrency, so it would not compile if wrong:

Non-detached Task inherits its actor context implicitly.

What would not compile is Task.detached {}

as these code touches the self properties, use @mainactor [weak self] in

as above #789 (comment)

if this cameraCaptureer.set fails, should we still set the selectedVideoDeviceID ?

How about
guard let capturer = getCameraCapturer() else { return }
do {
try await capturer.set(options: .init(device: videoDevice))
await MainActor.run {
self.selectedVideoDeviceID = videoDevice.uniqueID
}
} catch {
self.error = .mediaDevice(error)
}

Yep 99e74b8

BTW there's an issue to improve this API overall #177